import Server from './server'

const url = '/demo'

/* eslint class-methods-use-this: 0 */
class API extends Server {
  /**
   * 登录
   */
  async login (params) {
    try {
      const res = await this.axios('post', url + '/api/strongLogin', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 登出
   */
  async logout (params) {
    try {
      const res = await this.axios('get', url + '/api/logout', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 获取用户信息
   */
  async getUserInfo (params) {
    try {
      const res = await this.axios('post', url + '/userInfo/info', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 获取用户权限
   */
  async getRoleAndPerm (params) {
    try {
      const res = await this.axios('post', url + '/userInfo/getRoleAndPermisson', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 获取所有字典项
   */
  async getAllDic (params) {
    try {
      const res = await this.axios('post', url + '/common/allDic', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 用户管理 - 给当前登录用户修改密码
   */
  async modifyPasswd (params) {
    try {
      const res = await this.axios('post', url + '/sui_user/modifyPasswd', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 用户管理 - 分页模糊查询
   */
  async getUsersByPage (params) {
    try {
      const res = await this.axios('post', url + '/sui_user/findByFuzzyPage', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 用户管理 - 通过IDS批量删除用户
   */
  async deleteUsersByIds (params) {
    try {
      const res = await this.axios('post', url + '/sui_user/removeByIds', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 用户管理 - 新增用户
   */
  async addUser (params) {
    try {
      const res = await this.axios('post', url + '/sui_user/add', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 用户管理 - 修改用户
   */
  async updateUser (params) {
    try {
      const res = await this.axios('post', url + '/sui_user/modify', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 用户管理 - 通过ID给用户修改密码
   */
  async updatePasswdById (params) {
    try {
      const res = await this.axios('post', url + '/sui_user/modifyPasswdById', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 用户管理 - 通过ID给用户重置密码
   */
  async resetPasswd (params) {
    try {
      const res = await this.axios('post', url + '/sui_user/resetPasswd', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 用户管理 - 通过ID查询用户信息
   */
  async getUserById (params) {
    try {
      const res = await this.axios('post', url + '/sui_user/findById', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 用户管理 - 验证username是否可用(可用返回true, 不可用返回false)
   */
  async checkUsernameIsUsable (params) {
    try {
      const res = await this.axios('post', url + '/sui_user/checkUsernameIsUsable', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 用户管理 - 查找没有被人员关联过的普通用户(分页模糊)
   */
  async findUserUnrelatedPersonnel (params) {
    try {
      const res = await this.axios('post', url + '/sui_user/findUserUnrelatedPersonnel', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 组织机构 - 获取所有组织机构
   */
  async getAllOrg (params) {
    try {
      const res = await this.axios('post', url + '/sui_org/findAll', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 组织机构 - 分页模糊查询子孙节点
   */
  async getDescendantsByDim (params) {
    try {
      const res = await this.axios('post', url + '/sui_org/findDescendantsByIdFuzzyPage', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 组织机构 - 通过传入IDS批量删除组织机构
   */
  async deleteOrgByIds (params) {
    try {
      const res = await this.axios('post', url + '/sui_org/removeByIds', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 组织机构 - 新增组织机构
   */
  async addOrg (params) {
    try {
      const res = await this.axios('post', url + '/sui_org/add', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 组织机构 - 修改组织机构
   */
  async updateOrg (params) {
    try {
      const res = await this.axios('post', url + '/sui_org/modify', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 人员管理 - 通过组织机构ID分页模糊查询该组织机构下的所有人员
   */
  async getPersonnelsByOrgId (params) {
    try {
      const res = await this.axios('post', url + '/sui_personnel/findByOrgIdFuzzyPage', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 人员管理 - 通过IDS批量删除人员
   */
  async deletePersonnelByIds (params) {
    try {
      const res = await this.axios('post', url + '/sui_personnel/removeByIds', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 人员管理 - 新增人员
   */
  async addPersonnel (params) {
    try {
      const res = await this.axios('post', url + '/sui_personnel/add', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 人员管理 - 修改人员
   */
  async updatePersonnel (params) {
    try {
      const res = await this.axios('post', url + '/sui_personnel/modify', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 配置管理 - 分页模糊查询
   */
  async getConfigByPage (params) {
    try {
      const res = await this.axios('post', url + '/sui_config/findByFuzzyPage', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 配置管理 - 通过IDS批量删除配置
   */
  async deleteConfigByIds (params) {
    try {
      const res = await this.axios('post', url + '/sui_config/removeByIds', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 配置管理 - 新增配置
   */
  async addConfig (params) {
    try {
      const res = await this.axios('post', url + '/sui_config/add', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 配置管理 - 修改配置
   */
  async updateConfig (params) {
    try {
      const res = await this.axios('post', url + '/sui_config/modify', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 配置管理 - 通过code获取配置
   */
  async findConfigByCode (params) {
    try {
      const res = await this.axios('post', url + '/sui_config/findByCode', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 字典配置 - 新增字典项
   */
  async addDicItem (params) {
    try {
      const res = await this.axios('post', url + '/sui_dicItem/add', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 字典配置 - 通过IDS批量删除字典项
   */
  async deleteDicItemByIds (params) {
    try {
      const res = await this.axios('post', url + '/sui_dicItem/removeByIds', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 字典配置 - 修改字典项
   */
  async updateDicItem (params) {
    try {
      const res = await this.axios('post', url + '/sui_dicItem/modify', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 字典配置 - 新增字典
   */
  async addDic (params) {
    try {
      const res = await this.axios('post', url + '/sui_dic/add', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 字典配置 - 修改字典
   */
  async updateDic (params) {
    try {
      const res = await this.axios('post', url + '/sui_dic/modify', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 字典配置 - 通过ID删除字典
   */
  async deleteDicById (params) {
    try {
      const res = await this.axios('post', url + '/sui_dic/removeById', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 菜单管理 - 获取所有菜单
   */
  async getAllMenu (params) {
    try {
      const res = await this.axios('post', url + '/sui_menu/findAll', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 菜单管理 - 通过菜单ID获取详情
   */
  async getMenuDetail (params) {
    try {
      const res = await this.axios('post', url + '/sui_menu/findById', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 菜单管理 - 通过ID获取该菜单对应的所有权限
   */
  async getMenuPermById (params) {
    try {
      const res = await this.axios('post', url + '/sui_menu/getPermissionsById', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 菜单管理 - 新增菜单
   */
  async addMenu (params) {
    try {
      const res = await this.axios('post', url + '/sui_menu/add', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 字典配置 - 获取所有字典
   */
  async getAllDictionary (params) {
    try {
      const res = await this.axios('post', url + '/sui_dic/findAll', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 字典配置 - 通过字典ID获取其字典项
   */
  async getDicData (params) {
    try {
      const res = await this.axios('post', url + '/sui_dicItem/findByFuzzyPage', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 菜单管理 - 通过ID获取该菜单对应的所有权限
   */
  async findInfoByResourceIdAndType (params) {
    try {
      const res = await this.axios('post', url + '/sui/resourceOperation/findInfoByResourceIdAndType', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 菜单管理 - 修改菜单
   */
  async updateMenu (params) {
    try {
      const res = await this.axios('post', url + '/sui_menu/modify', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 菜单管理 - 通过ID删除菜单
   */
  async deleteMenuById (params) {
    try {
      const res = await this.axios('post', url + '/sui_menu/removeById', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 权限操作 - 菜单分配到权限（新增）
   */
  async addResourceOperation (params) {
    try {
      const res = await this.axios('post', url + '/sui/resourceOperation/add', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 权限操作 - 菜单分配到权限（修改）
   */
  async modifyResourceOperation (params) {
    try {
      const res = await this.axios('post', url + '/sui/resourceOperation/modify', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 模块组树 - 获取模块组树展示数据
   */
  async getMGroupTreeCurr (params) {
    try {
      const res = await this.axios('post', url + '/sui/mgroupTree/getTreeCurr', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 菜单管理 - 获取当前登录用户拥有权限的菜单
   */
  async findMenuOfCurrUser (params) {
    try {
      const res = await this.axios('post', url + '/sui_menu/findByPermission', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 用户组管理 - 新增用户
   */
  async addPersonneltoGroup (params) {
    try {
      const res = await this.axios('post', url + '/sui_userUgroup/addByUserIdsAndUgroupId', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 用户组管理 - 通过IDS批量删除关联用户组的用户
   */
  async deleteUgRolesByUgidAndRoleids (params) {
    try {
      const res = await this.axios('post', url + '/sui_ugroupRole/removeByUgroupIdAndRoleIds', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 用户组管理 - 通过IDS批量删除关联用户组的角色
   */
  async deleteUgUsersByUgidAndUserids (params) {
    try {
      const res = await this.axios('post', url + '/sui_userUgroup/removeByUserIdsAndUgroupId', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 用户组管理 - 获取所有用户组
   */
  async getAllUsergroup_api (params) {
    try {
      const res = await this.axios('post', url + '/sui_ugroup/findAll', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /**
   * 接口表格
   */
  async getInterfaceTable (params) {
    try {
      const res = await this.axios('post', url + '/sui/interface/findInfoByFuzzyPage', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /**
   *模块用户树
   */
  async getMPTree (params) {
    try {
      const res = await this.axios('post', url + '/sui/mgroupTree/getTree', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /**
   * 资源权限 /sui/interface/modify
   */
  async relevResourcePermission (params) {
    try {
      const res = await this.axios('post', url + '/sui/resourceOperation/add', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /**
   * 修改接口 /sui/interface/modify
   */
  async patchInterface (params) {
    try {
      const res = await this.axios('post', url + '/sui/interface/modify', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /**
   * 新增接口 /sui/interface/modify
   */
  async addInterface (params) {
    try {
      const res = await this.axios('post', url + '/sui/interface/add', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    组织机构管理 - 接口管理 -  删除接口
  */
  async deleteInterface (params) {
    try {
      const res = await this.axios('post', url + '/sui/interface/removeByIds', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    组织结构管理 - 页面元素 -表格渲染
  */
  async getPageItemTable (params) {
    try {
      const res = await this.axios('post', url + '/sui/resourceElement/findInfoByFuzzyPage', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    组织结构管理 - 页面元素 - 修改页面元素
  */

  async patchPageItem (params) {
    try {
      const res = await this.axios('post', url + '/sui/resourceElement/modify', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    组织结构管理 - 页面元素 - 删除页面元素
  */

  async deletePageItem (params) {
    try {
      const res = await this.axios('post', url + '/sui/resourceElement/removeByIds', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    组织结构管理 - 页面元素 - 新增页面元素 /sui_ugroup/findAll
  */
  async addPageItem (params) {
    try {
      const res = await this.axios('post', url + '/sui/resourceElement/add', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    角色管理 - 角色管理 - 操作角色树
  */
  async getCurrRole (params) {
    try {
      const res = await this.axios('post', url + '/sui/rgroupTree/getTreeCurr', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    角色管理 - 角色管理 - 角色左侧树 /sui/role/findByRgroupIdFuzzyPage
  */
  async getAllrole (params) {
    try {
      const res = await this.axios('post', url + '/sui/rgroupTree/getTreeNotLazy', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
   根据角色组找到角色 //sui/role/add 分页
  */
  async findRoleByRoleGroupId (params) {
    try {
      const res = await this.axios('post', url + '/sui/role/findByRgroupIdOnlySelfFuzzyPage', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
   增加角色 / 分页
  */
  async addRoleByRoleGroupId (params) {
    try {
      const res = await this.axios('post', url + '/sui/role/add', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
   角色管理 - 角色管理 - 修改角色 patchRoleById
 */
  async patchRoleById (params) {
    try {
      const res = await this.axios('post', url + '/sui/role/modify', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    角色管理 - 用户权限管理 - 获取左侧树 /sui/peprmission/removeById
  */
  async getTreeData (params) {
    try {
      const res = await this.axios('post', url + '/sui_user/getTree', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    角色管理 - 用户权限管理 - 获取人员详情 /sui/peprmission/removeById
  */
  async getPersonDetail (params) {
    try {
      const res = await this.axios('post', url + '/sui_personnel/findById', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    角色管理 - 用户角色管理 - 根据用户查人员 /sui/userRole/addAndRemoveByUserIdAndRoleIds
  */
  async getPersonByUserId (params) {
    try {
      const res = await this.axios('post', url + '/sui_personnel/findByUserId', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    角色管理 - 用户角色管理 - 根据用户查角色 /sui/userRole/getRolesByUserIdPage
  */
  async getRolesByUserId (params) {
    try {
      const res = await this.axios('post', url + '/sui/userRole/getRolesByUserId', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    角色管理 - 用户角色管理 - 根据用户查角色 分页
  */
  async getRolesByUserIdPage (params) {
    try {
      const res = await this.axios('post', url + '/sui/userRole/getRolesByUserIdPage', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    角色管理 - 用户角色管理 -移除用户下的角色 /sui/userRole/addAndRemoveByUserIdAndRoleIds
  */
  async removeUserInRole (params) {
    try {
      const res = await this.axios('post', url + '/sui/userRole/removeByUserIdAndRoleIds', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    角色管理 - 用户角色管理 - 关联用户角色 /sui/rolePermission/addByRoleIdAndPermissionIds
  */
  async removeAndAddRole (params) {
    try {
      const res = await this.axios('post', url + '/sui/userRole/addAndRemoveByUserIdAndRoleIds', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    角色管理 - 角色权限 - 根据角色id查权限分页 /sui/permission/findByRoleIdFuzzyPage
  */
  async findByRoleIdFuzzyPage (params) {
    try {
      const res = await this.axios('post', url + '/sui/rolePermission/getPermissionsByRoleIdPage', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    角色管理 - 角色权限管理 - 根据角色id查权限 /sui/rolePermission/addAndRemoveByRoleIdAndPermissionIds
  */
  async findByRoleId (params) {
    try {
      const res = await this.axios('post', url + '/sui/rolePermission/getPermissionsByRoleId', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    角色管理 - 角色权限管理 - 角色权限关联
  */
  async removeAndAddPer (params) {
    try {
      const res = await this.axios('post', url + '/sui/rolePermission/addAndRemoveByRoleIdAndPermissionIds', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    角色管理 - 角色权限管理 - 取消角色权限关联 /sui/permission/findByIds
  */
  async removeByRoleIdAndPermissionIds (params) {
    try {
      const res = await this.axios('post', url + '/sui/rolePermission/removeByRoleIdAndPermissionIds', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    角色管理 - 权限管理 - 权限详情 /sui/resourceOperation/findByPermissionIds
  */
  async getPermissionByid (params) {
    try {
      const res = await this.axios('post', url + '/sui/permission/findByIds', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    角色管理 - 权限管理 - 资源权限操作详情 /sui/resourceOperation/findByPermissionIds
  */
  async getResourceByid (params) {
    try {
      const res = await this.axios('post', url + '/sui/resourceOperation/findInfoByPermissionIds', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    角色 - 角色管理 -  增加角色组 /sui/rgroup/add
  */
  async addRoleGroup (params) {
    try {
      const res = await this.axios('post', url + '/sui/rgroup/add', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    角色 - 角色管理 -  增加角色组 /sui/rgroup/add
  */
  async editRoleGroup (params) {
    try {
      const res = await this.axios('post', url + '/sui/rgroup/modify', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    组织机构管理 - 权限管理 -  指定权限批量移除操作
  */
  async removeByResourceIdsAndPermissionId (params) {
    try {
      const res = await this.axios('post', url + '/sui/resourceOperation/removeByResourceIdsAndPermissionId', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    组织机构管理 - 权限管理 - 更改权限 /sui/peprmission/removeById
  */
  async patchPerModel (params) {
    try {
      const res = await this.axios('post', url + '/sui/permission/modify', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    组织机构管理 - 创建新权限
  */
  async addPermission (params) {
    try {
      const res = await this.axios('post', url + '/sui/permission/add', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    组织机构管理 - 新增子模块
  */
  async addchildGroup (params) {
    try {
      const res = await this.axios('post', url + '/sui/mgroup/add', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    组织机构管理 - 权限管理 - 修改模块 /sui/rgroup/removeById
  */
  async patchModel (params) {
    try {
      const res = await this.axios('post', url + '/sui/mgroup/modify', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    角色 - 角色组 - 删除角色组 /sui/rgroup/removeById
  */
  async delRoleGroup (params) {
    try {
      const res = await this.axios('post', url + '/sui/rgroup/removeById', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    组织机构 - 用户组管理 - 用过用户组查角色 /sui/rgroup/removeById
  */
  async getUsersByUgroupId (params) {
    try {
      const res = await this.axios('post', url + '/sui_userUgroup/getUsersByUgroupIdFuzzyPage', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    组织机构 - 用户组管理 - 通过用户组查角色   /sui_user/findAll
  */
  async getUsersByUgroupIdNotPage (params) {
    try {
      const res = await this.axios('post', url + '/sui_userUgroup/getUsersByUgroupId', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    组织机构 - 用户组管理 - 用过用户组查角色   /sui_userUgroup/addAndRemoveByUserIdsAndUgroupId
  */
  async getAllUser (params) {
    try {
      const res = await this.axios('post', url + '/sui_user/findAll', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    组织机构 - 用户组管理 - 用户用户组关联   /sui_userUgroup/addAndRemoveByUserIdsAndUgroupId
  */
  async removeAndAddUser (params) {
    try {
      const res = await this.axios('post', url + '/sui_userUgroup/addAndRemoveByUserIdsAndUgroupId', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    组织机构 - 用户组管理 - 增加用户组   /sui_ugroup/modify
  */
  async addUgroupByPid (params) {
    try {
      const res = await this.axios('post', url + '/sui_ugroup/add', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    组织机构 - 用户组管理 - 更改用户组   /sui_ugroup/modify
  */
  async updateUserGroupById (params) {
    try {
      const res = await this.axios('post', url + '/sui_ugroup/modify', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    组织机构 - 用户组管理 - 删除用户组   /sui_ugroupRole/removeByUgroupIdAndRoleIds
  */
  async deleteUserGroupById (params) {
    try {
      const res = await this.axios('post', url + '/sui_ugroup/removeById', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    组织机构 - 用户组管理 - 移除用户用户组关联   /sui_ugroupRole/removeByUgroupIdAndRoleIds
  */
  async removeByUgroupIdAndRoleIds (params) {
    try {
      const res = await this.axios('post', url + '/sui_userUgroup/removeByUserIdsAndUgroupId', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    组织机构 - 用户组管理 - 获取用户组下所有角色   /sui_ugroupRole/addAndRemoveByUgroupIdAndRoleIds
  */
  async getRolesByUgroupId (params) {
    try {
      const res = await this.axios('post', url + '/sui_ugroupRole/getRolesByUgroupIdFuzzyPage', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    用户组管理 - 用户组管理 - 获取用户组下所有角色   /sui_ugroupRole/addAndRemoveByUgroupIdAndRoleIds
  */
  async getCheckedRolesByUgroupId (params) {
    try {
      const res = await this.axios('post', url + '/sui_ugroupRole/getRolesByUgroupId', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    组织机构 - 用户组管理 - 关联用户组角色  /sui_user/findByLikeUsername
  */
  async addRgroupAndRole (params) {
    try {
      const res = await this.axios('post', url + '/sui_ugroupRole/addAndRemoveByUgroupIdAndRoleIds', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    组织机构 - 用户组管理 - 关联用户组角色  /sui_user/findByLikeUsername
  */
  async getUserByUsername (params) {
    try {
      const res = await this.axios('post', url + '/sui_user/findByLikeNickname', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    组织机构 - 用户组管理 - 模糊搜索角色 /sui/permission/findByLikeName
  */
  async getRoleByUserName (params) {
    try {
      const res = await this.axios('post', url + '/sui/role/findByLikeName', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    组织机构 - 用户组管理 - 模糊搜索权限 /sui/permission/removeById
  */
  async getpermissionByName (params) {
    try {
      const res = await this.axios('post', url + '/sui/permission/findByLikeName', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    授权管理 - 权限管理 - 删除权限 /sui/role/removeById
  */
  async deletePer (params) {
    try {
      const res = await this.axios('post', url + '/sui/permission/removeById', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    授权管理 - 角色管理 - 删除角色 /sui/role/removeById
  */
  async delRole (params) {
    try {
      const res = await this.axios('post', url + '/sui/role/removeById', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    授权管理 - 用户管理 - 通过userId查uGroup /sui_userUgroup/getUgroupsByUserIdPage
g
  */
  async getUgroupsByUserId (params) {
    try {
      const res = await this.axios('post', url + '/sui_userUgroup/getUgroupsByUserId', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    授权管理 - 用户管理 - 通过userId查uGroup(分页)
  */
  async getUgroupsByUserIdPage (params) {
    try {
      const res = await this.axios('post', url + '/sui_userUgroup/getUgroupsByUserIdPage', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    授权管理 - 用户管理 - 操作用户组 /sui_userUgroup/removeByUserIdAndUgroupIds

  */
  async optionUgroup (params) {
    try {
      const res = await this.axios('post', url + '/sui_userUgroup/addAndRemoveByUserIdAndUgroupIds', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    授权管理 - 用户授权 - 删除用户组 /sui_user/findByLikeUsername

  */
  async deleteUgroup (params) {
    try {
      const res = await this.axios('post', url + '/sui_userUgroup/removeByUserIdAndUgroupIds', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    授权管理 - 用户授权 - 通过名字查询用户 /sui_user/findByLikeUsername

  */
  async getUgroupByName (params) {
    try {
      const res = await this.axios('post', url + '/sui_ugroup/findByLikeName', params)
      return res
    } catch (err) {
      throw err
    }
  }
  /*
    授权管理 - 用户授权 - 删除模块 /sui_user/findByLikeUsername

  */
  async deleteMgroup (params) {
    try {
      const res = await this.axios('post', url + '/sui/mgroup/removeById', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 通知公告 - 列表分页查询
   */
  async findNoticeByFuzzyPage (params) {
    try {
      const res = await this.axios('post', url + '/notice/findByFuzzyPage', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 通知公告 - 根据ID查询详情
   */
  async findNoticeInfoById (params) {
    try {
      const res = await this.axios('post', url + '/notice/findInfoById', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 通知公告 - 取消发布
   */
  async cancelNotice (params) {
    try {
      const res = await this.axios('post', url + '/notice/cancel', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 通知公告 - 撤销已发布的通知
   */
  async recallNotice (params) {
    try {
      const res = await this.axios('post', url + '/notice/recall', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 通知公告 - 发布
   */
  async releaseNotice (params) {
    try {
      const res = await this.axios('post', url + '/notice/release', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 通知公告 - 定时发布
   */
  async releaseNoticeByTime (params) {
    try {
      const res = await this.axios('post', url + '/notice/releaseByTime', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 通知公告 - 删除
   */
  async removeNoticeById (params) {
    try {
      const res = await this.axios('post', url + '/notice/removeById', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 通知公告 - 保存
   */
  async saveNotice (params) {
    try {
      const res = await this.axios('post', url + '/notice/save', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 权限关系管理 - 获取权限关系集合树
   */
  async getPermRelTree (params) {
    try {
      const res = await this.axios('post', url + '/sui/permRel/tree/get', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 权限关系管理 - 新增权限关系集合
   */
  async addPermRel (params) {
    try {
      const res = await this.axios('post', url + '/sui/permRel/add', params)
      return res
    } catch (err) {
      throw err
    }
  }
  
  /**
   * 权限关系管理 - 修改权限关系集合
   */
  async modifyPermRel (params) {
    try {
      const res = await this.axios('post', url + '/sui/permRel/modify', params)
      return res
    } catch (err) {
      throw err
    }
  }
  
  /**
   * 权限关系管理 - 通过ids批量删除权限关系集合
   */
  async removePermRel (params) {
    try {
      const res = await this.axios('post', url + '/sui/permRel/remove', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 权限关系管理 - 新增权限关系集合项
   */
  async addPermRelPtag (params) {
    try {
      const res = await this.axios('post', url + '/sui/permRel/ptag/add', params)
      return res
    } catch (err) {
      throw err
    }
  }
  
  /**
   * 权限关系管理 - 修改权限关系集合项
   */
  async modifyPermRelPtag (params) {
    try {
      const res = await this.axios('post', url + '/sui/permRel/ptag/modify', params)
      return res
    } catch (err) {
      throw err
    }
  }
  
  /**
   * 权限关系管理 - 通过ids批量删除权限关系集合项
   */
  async removePermRelPtag (params) {
    try {
      const res = await this.axios('post', url + '/sui/permRel/ptag/remove', params)
      return res
    } catch (err) {
      throw err
    }
  }
  
  /**
   * 权限关系管理 - 通过集合项id分页查询权限集合
   */
  async getPermPage (params) {
    try {
      const res = await this.axios('post', url + '/sui/permRel/ptag/getPermPage', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 权限关系管理 - 根据关系集合id查询权限
   */
  async findPermsByPtagId (params) {
    try {
      const res = await this.axios('post', url + '/sui/permRel/ptag/findByPtagId', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 权限关系管理 - 维护权限关系集合
   */
  async addAndRemovePermPtag (params) {
    try {
      const res = await this.axios('post', url + '/sui/permRel/ptag/addAndRemovePerm', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 审计管理 - 审计日志
   */
  async findAuditLogByFuzzyPage (params) {
    try {
      const res = await this.axios('post', url + '/sui_auditLog/findByFuzzyPage', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 审计管理 - 登录日志
   */
  async findLoginLogByFuzzyPage (params) {
    try {
      const res = await this.axios('post', url + '/sui_loginLog/findByFuzzyPage', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 审计管理 - 异常报警
   */
  async findWarningByFuzzyPage (params) {
    try {
      const res = await this.axios('post', url + '/sui/warning/findByFuzzyPage', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 消息提醒 - 分页查询
   */
  async findMsgByFuzzyPage (params) {
    try {
      const res = await this.axios('post', url + '/sui/msg/findCurrFuzzyPage', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 消息提醒 - 根据ids批量修改消息状态
   */
  async modifyMsgReadByIds (params) {
    try {
      const res = await this.axios('post', url + '/sui/msg/read', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 消息提醒 - 根据当前登录人获取未读消息条数
   */
  async findCurrUnReadMsgNum (params) {
    try {
      const res = await this.axios('post', url + '/sui/msg/findCurrUnReadMsgNum', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 用户管理 - 临时用户延期
   */
  async activeUser (params) {
    try {
      const res = await this.axios('post', url + '/sui_user/activeUser', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 用户管理 - 解锁用户
   */
  async unlockUser (params) {
    try {
      const res = await this.axios('post', url + '/sui_user/unlockUser', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 用户组管理 - '操作用户'按钮权限
   */
  async hasRole (params) {
    try {
      const res = await this.axios('post', url + '/sui_userUgroup/hasRole', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 安全配置管理 - 通过编码查询安全配置
   */
  async findSafeConfigByCode (params) {
    try {
      const res = await this.axios('post', url + '/sui/config/safe/findByCode', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 安全配置管理 - 查询所有安全配置
   */
  async findAllSafeConfig (params) {
    try {
      const res = await this.axios('post', url + '/sui/config/safe/findAll', params)
      return res
    } catch (err) {
      throw err
    }
  }

  /**
   * 安全配置管理 - 修改安全配置
   */
  async modifySafeConfig (params) {
    try {
      const res = await this.axios('post', url + '/sui/config/safe/modify', params)
      return res
    } catch (err) {
      throw err
    }
  }
}
export default new API()
